home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / libxml2 / libxml / tree.h < prev    next >
C/C++ Source or Header  |  2006-04-25  |  33KB  |  1,155 lines
  1. /*
  2.  * Summary: interfaces for tree manipulation
  3.  * Description: this module describes the structures found in an tree resulting
  4.  *              from an XML or HTML parsing, as well as the API provided for
  5.  *              various processing on that tree
  6.  *
  7.  * Copy: See Copyright for the status of this software.
  8.  *
  9.  * Author: Daniel Veillard
  10.  */
  11.  
  12. #ifndef __XML_TREE_H__
  13. #define __XML_TREE_H__
  14.  
  15. #include <stdio.h>
  16. #include <libxml/xmlversion.h>
  17. #include <libxml/xmlstring.h>
  18.  
  19. #ifdef __cplusplus
  20. extern "C" {
  21. #endif
  22.  
  23. /*
  24.  * Some of the basic types pointer to structures:
  25.  */
  26. /* xmlIO.h */
  27. typedef struct _xmlParserInputBuffer xmlParserInputBuffer;
  28. typedef xmlParserInputBuffer *xmlParserInputBufferPtr;
  29.  
  30. typedef struct _xmlOutputBuffer xmlOutputBuffer;
  31. typedef xmlOutputBuffer *xmlOutputBufferPtr;
  32.  
  33. /* parser.h */
  34. typedef struct _xmlParserInput xmlParserInput;
  35. typedef xmlParserInput *xmlParserInputPtr;
  36.  
  37. typedef struct _xmlParserCtxt xmlParserCtxt;
  38. typedef xmlParserCtxt *xmlParserCtxtPtr;
  39.  
  40. typedef struct _xmlSAXLocator xmlSAXLocator;
  41. typedef xmlSAXLocator *xmlSAXLocatorPtr;
  42.  
  43. typedef struct _xmlSAXHandler xmlSAXHandler;
  44. typedef xmlSAXHandler *xmlSAXHandlerPtr;
  45.  
  46. /* entities.h */
  47. typedef struct _xmlEntity xmlEntity;
  48. typedef xmlEntity *xmlEntityPtr;
  49.  
  50. /**
  51.  * BASE_BUFFER_SIZE:
  52.  *
  53.  * default buffer size 4000.
  54.  */
  55. #define BASE_BUFFER_SIZE 4096
  56.  
  57. /**
  58.  * xmlBufferAllocationScheme:
  59.  *
  60.  * A buffer allocation scheme can be defined to either match exactly the
  61.  * need or double it's allocated size each time it is found too small.
  62.  */
  63.  
  64. typedef enum {
  65.     XML_BUFFER_ALLOC_DOUBLEIT,
  66.     XML_BUFFER_ALLOC_EXACT,
  67.     XML_BUFFER_ALLOC_IMMUTABLE
  68. } xmlBufferAllocationScheme;
  69.  
  70. /**
  71.  * xmlBuffer:
  72.  *
  73.  * A buffer structure.
  74.  */
  75. typedef struct _xmlBuffer xmlBuffer;
  76. typedef xmlBuffer *xmlBufferPtr;
  77. struct _xmlBuffer {
  78.     xmlChar *content;        /* The buffer content UTF8 */
  79.     unsigned int use;        /* The buffer size used */
  80.     unsigned int size;        /* The buffer size */
  81.     xmlBufferAllocationScheme alloc; /* The realloc method */
  82. };
  83.  
  84. /**
  85.  * XML_XML_NAMESPACE:
  86.  *
  87.  * This is the namespace for the special xml: prefix predefined in the
  88.  * XML Namespace specification.
  89.  */
  90. #define XML_XML_NAMESPACE \
  91.     (const xmlChar *) "http://www.w3.org/XML/1998/namespace"
  92.  
  93. /**
  94.  * XML_XML_ID:
  95.  *
  96.  * This is the name for the special xml:id attribute
  97.  */
  98. #define XML_XML_ID (const xmlChar *) "xml:id"
  99.  
  100. /*
  101.  * The different element types carried by an XML tree.
  102.  *
  103.  * NOTE: This is synchronized with DOM Level1 values
  104.  *       See http://www.w3.org/TR/REC-DOM-Level-1/
  105.  *
  106.  * Actually this had diverged a bit, and now XML_DOCUMENT_TYPE_NODE should
  107.  * be deprecated to use an XML_DTD_NODE.
  108.  */
  109. typedef enum {
  110.     XML_ELEMENT_NODE=        1,
  111.     XML_ATTRIBUTE_NODE=        2,
  112.     XML_TEXT_NODE=        3,
  113.     XML_CDATA_SECTION_NODE=    4,
  114.     XML_ENTITY_REF_NODE=    5,
  115.     XML_ENTITY_NODE=        6,
  116.     XML_PI_NODE=        7,
  117.     XML_COMMENT_NODE=        8,
  118.     XML_DOCUMENT_NODE=        9,
  119.     XML_DOCUMENT_TYPE_NODE=    10,
  120.     XML_DOCUMENT_FRAG_NODE=    11,
  121.     XML_NOTATION_NODE=        12,
  122.     XML_HTML_DOCUMENT_NODE=    13,
  123.     XML_DTD_NODE=        14,
  124.     XML_ELEMENT_DECL=        15,
  125.     XML_ATTRIBUTE_DECL=        16,
  126.     XML_ENTITY_DECL=        17,
  127.     XML_NAMESPACE_DECL=        18,
  128.     XML_XINCLUDE_START=        19,
  129.     XML_XINCLUDE_END=        20
  130. #ifdef LIBXML_DOCB_ENABLED
  131.    ,XML_DOCB_DOCUMENT_NODE=    21
  132. #endif
  133. } xmlElementType;
  134.  
  135.  
  136. /**
  137.  * xmlNotation:
  138.  *
  139.  * A DTD Notation definition.
  140.  */
  141.  
  142. typedef struct _xmlNotation xmlNotation;
  143. typedef xmlNotation *xmlNotationPtr;
  144. struct _xmlNotation {
  145.     const xmlChar               *name;            /* Notation name */
  146.     const xmlChar               *PublicID;    /* Public identifier, if any */
  147.     const xmlChar               *SystemID;    /* System identifier, if any */
  148. };
  149.  
  150. /**
  151.  * xmlAttributeType:
  152.  *
  153.  * A DTD Attribute type definition.
  154.  */
  155.  
  156. typedef enum {
  157.     XML_ATTRIBUTE_CDATA = 1,
  158.     XML_ATTRIBUTE_ID,
  159.     XML_ATTRIBUTE_IDREF    ,
  160.     XML_ATTRIBUTE_IDREFS,
  161.     XML_ATTRIBUTE_ENTITY,
  162.     XML_ATTRIBUTE_ENTITIES,
  163.     XML_ATTRIBUTE_NMTOKEN,
  164.     XML_ATTRIBUTE_NMTOKENS,
  165.     XML_ATTRIBUTE_ENUMERATION,
  166.     XML_ATTRIBUTE_NOTATION
  167. } xmlAttributeType;
  168.  
  169. /**
  170.  * xmlAttributeDefault:
  171.  *
  172.  * A DTD Attribute default definition.
  173.  */
  174.  
  175. typedef enum {
  176.     XML_ATTRIBUTE_NONE = 1,
  177.     XML_ATTRIBUTE_REQUIRED,
  178.     XML_ATTRIBUTE_IMPLIED,
  179.     XML_ATTRIBUTE_FIXED
  180. } xmlAttributeDefault;
  181.  
  182. /**
  183.  * xmlEnumeration:
  184.  *
  185.  * List structure used when there is an enumeration in DTDs.
  186.  */
  187.  
  188. typedef struct _xmlEnumeration xmlEnumeration;
  189. typedef xmlEnumeration *xmlEnumerationPtr;
  190. struct _xmlEnumeration {
  191.     struct _xmlEnumeration    *next;    /* next one */
  192.     const xmlChar            *name;    /* Enumeration name */
  193. };
  194.  
  195. /**
  196.  * xmlAttribute:
  197.  *
  198.  * An Attribute declaration in a DTD.
  199.  */
  200.  
  201. typedef struct _xmlAttribute xmlAttribute;
  202. typedef xmlAttribute *xmlAttributePtr;
  203. struct _xmlAttribute {
  204.     void           *_private;            /* application data */
  205.     xmlElementType          type;       /* XML_ATTRIBUTE_DECL, must be second ! */
  206.     const xmlChar          *name;    /* Attribute name */
  207.     struct _xmlNode    *children;    /* NULL */
  208.     struct _xmlNode        *last;    /* NULL */
  209.     struct _xmlDtd       *parent;    /* -> DTD */
  210.     struct _xmlNode        *next;    /* next sibling link  */
  211.     struct _xmlNode        *prev;    /* previous sibling link  */
  212.     struct _xmlDoc          *doc;       /* the containing document */
  213.  
  214.     struct _xmlAttribute  *nexth;    /* next in hash table */
  215.     xmlAttributeType       atype;    /* The attribute type */
  216.     xmlAttributeDefault      def;    /* the default */
  217.     const xmlChar  *defaultValue;    /* or the default value */
  218.     xmlEnumerationPtr       tree;       /* or the enumeration tree if any */
  219.     const xmlChar        *prefix;    /* the namespace prefix if any */
  220.     const xmlChar          *elem;    /* Element holding the attribute */
  221. };
  222.  
  223. /**
  224.  * xmlElementContentType:
  225.  *
  226.  * Possible definitions of element content types.
  227.  */
  228. typedef enum {
  229.     XML_ELEMENT_CONTENT_PCDATA = 1,
  230.     XML_ELEMENT_CONTENT_ELEMENT,
  231.     XML_ELEMENT_CONTENT_SEQ,
  232.     XML_ELEMENT_CONTENT_OR
  233. } xmlElementContentType;
  234.  
  235. /**
  236.  * xmlElementContentOccur:
  237.  *
  238.  * Possible definitions of element content occurrences.
  239.  */
  240. typedef enum {
  241.     XML_ELEMENT_CONTENT_ONCE = 1,
  242.     XML_ELEMENT_CONTENT_OPT,
  243.     XML_ELEMENT_CONTENT_MULT,
  244.     XML_ELEMENT_CONTENT_PLUS
  245. } xmlElementContentOccur;
  246.  
  247. /**
  248.  * xmlElementContent:
  249.  *
  250.  * An XML Element content as stored after parsing an element definition
  251.  * in a DTD.
  252.  */
  253.  
  254. typedef struct _xmlElementContent xmlElementContent;
  255. typedef xmlElementContent *xmlElementContentPtr;
  256. struct _xmlElementContent {
  257.     xmlElementContentType     type;    /* PCDATA, ELEMENT, SEQ or OR */
  258.     xmlElementContentOccur    ocur;    /* ONCE, OPT, MULT or PLUS */
  259.     const xmlChar             *name;    /* Element name */
  260.     struct _xmlElementContent *c1;    /* first child */
  261.     struct _xmlElementContent *c2;    /* second child */
  262.     struct _xmlElementContent *parent;    /* parent */
  263.     const xmlChar             *prefix;    /* Namespace prefix */
  264. };
  265.  
  266. /**
  267.  * xmlElementTypeVal:
  268.  *
  269.  * The different possibilities for an element content type.
  270.  */
  271.  
  272. typedef enum {
  273.     XML_ELEMENT_TYPE_UNDEFINED = 0,
  274.     XML_ELEMENT_TYPE_EMPTY = 1,
  275.     XML_ELEMENT_TYPE_ANY,
  276.     XML_ELEMENT_TYPE_MIXED,
  277.     XML_ELEMENT_TYPE_ELEMENT
  278. } xmlElementTypeVal;
  279.  
  280. #ifdef __cplusplus
  281. }
  282. #endif
  283. #include <libxml/xmlregexp.h>
  284. #ifdef __cplusplus
  285. extern "C" {
  286. #endif
  287.  
  288. /**
  289.  * xmlElement:
  290.  *
  291.  * An XML Element declaration from a DTD.
  292.  */
  293.  
  294. typedef struct _xmlElement xmlElement;
  295. typedef xmlElement *xmlElementPtr;
  296. struct _xmlElement {
  297.     void           *_private;            /* application data */
  298.     xmlElementType          type;       /* XML_ELEMENT_DECL, must be second ! */
  299.     const xmlChar          *name;    /* Element name */
  300.     struct _xmlNode    *children;    /* NULL */
  301.     struct _xmlNode        *last;    /* NULL */
  302.     struct _xmlDtd       *parent;    /* -> DTD */
  303.     struct _xmlNode        *next;    /* next sibling link  */
  304.     struct _xmlNode        *prev;    /* previous sibling link  */
  305.     struct _xmlDoc          *doc;       /* the containing document */
  306.  
  307.     xmlElementTypeVal      etype;    /* The type */
  308.     xmlElementContentPtr content;    /* the allowed element content */
  309.     xmlAttributePtr   attributes;    /* List of the declared attributes */
  310.     const xmlChar        *prefix;    /* the namespace prefix if any */
  311. #ifdef LIBXML_REGEXP_ENABLED
  312.     xmlRegexpPtr       contModel;    /* the validating regexp */
  313. #else
  314.     void          *contModel;
  315. #endif
  316. };
  317.  
  318.  
  319. /**
  320.  * XML_LOCAL_NAMESPACE:
  321.  *
  322.  * A namespace declaration node.
  323.  */
  324. #define XML_LOCAL_NAMESPACE XML_NAMESPACE_DECL
  325. typedef xmlElementType xmlNsType;
  326.  
  327. /**
  328.  * xmlNs:
  329.  *
  330.  * An XML namespace.
  331.  * Note that prefix == NULL is valid, it defines the default namespace
  332.  * within the subtree (until overridden).
  333.  *
  334.  * xmlNsType is unified with xmlElementType.
  335.  */
  336.  
  337. typedef struct _xmlNs xmlNs;
  338. typedef xmlNs *xmlNsPtr;
  339. struct _xmlNs {
  340.     struct _xmlNs  *next;    /* next Ns link for this node  */
  341.     xmlNsType      type;    /* global or local */
  342.     const xmlChar *href;    /* URL for the namespace */
  343.     const xmlChar *prefix;    /* prefix for the namespace */
  344.     void           *_private;   /* application data */
  345. };
  346.  
  347. /**
  348.  * xmlDtd:
  349.  *
  350.  * An XML DTD, as defined by <!DOCTYPE ... There is actually one for
  351.  * the internal subset and for the external subset.
  352.  */
  353. typedef struct _xmlDtd xmlDtd;
  354. typedef xmlDtd *xmlDtdPtr;
  355. struct _xmlDtd {
  356.     void           *_private;    /* application data */
  357.     xmlElementType  type;       /* XML_DTD_NODE, must be second ! */
  358.     const xmlChar *name;    /* Name of the DTD */
  359.     struct _xmlNode *children;    /* the value of the property link */
  360.     struct _xmlNode *last;    /* last child link */
  361.     struct _xmlDoc  *parent;    /* child->parent link */
  362.     struct _xmlNode *next;    /* next sibling link  */
  363.     struct _xmlNode *prev;    /* previous sibling link  */
  364.     struct _xmlDoc  *doc;    /* the containing document */
  365.  
  366.     /* End of common part */
  367.     void          *notations;   /* Hash table for notations if any */
  368.     void          *elements;    /* Hash table for elements if any */
  369.     void          *attributes;  /* Hash table for attributes if any */
  370.     void          *entities;    /* Hash table for entities if any */
  371.     const xmlChar *ExternalID;    /* External identifier for PUBLIC DTD */
  372.     const xmlChar *SystemID;    /* URI for a SYSTEM or PUBLIC DTD */
  373.     void          *pentities;   /* Hash table for param entities if any */
  374. };
  375.  
  376. /**
  377.  * xmlAttr:
  378.  *
  379.  * An attribute on an XML node.
  380.  */
  381. typedef struct _xmlAttr xmlAttr;
  382. typedef xmlAttr *xmlAttrPtr;
  383. struct _xmlAttr {
  384.     void           *_private;    /* application data */
  385.     xmlElementType   type;      /* XML_ATTRIBUTE_NODE, must be second ! */
  386.     const xmlChar   *name;      /* the name of the property */
  387.     struct _xmlNode *children;    /* the value of the property */
  388.     struct _xmlNode *last;    /* NULL */
  389.     struct _xmlNode *parent;    /* child->parent link */
  390.     struct _xmlAttr *next;    /* next sibling link  */
  391.     struct _xmlAttr *prev;    /* previous sibling link  */
  392.     struct _xmlDoc  *doc;    /* the containing document */
  393.     xmlNs           *ns;        /* pointer to the associated namespace */
  394.     xmlAttributeType atype;     /* the attribute type if validating */
  395.     void            *psvi;    /* for type/PSVI informations */
  396. };
  397.  
  398. /**
  399.  * xmlID:
  400.  *
  401.  * An XML ID instance.
  402.  */
  403.  
  404. typedef struct _xmlID xmlID;
  405. typedef xmlID *xmlIDPtr;
  406. struct _xmlID {
  407.     struct _xmlID    *next;    /* next ID */
  408.     const xmlChar    *value;    /* The ID name */
  409.     xmlAttrPtr        attr;    /* The attribute holding it */
  410.     const xmlChar    *name;    /* The attribute if attr is not available */
  411.     int               lineno;    /* The line number if attr is not available */
  412.     struct _xmlDoc   *doc;    /* The document holding the ID */
  413. };
  414.  
  415. /**
  416.  * xmlRef:
  417.  *
  418.  * An XML IDREF instance.
  419.  */
  420.  
  421. typedef struct _xmlRef xmlRef;
  422. typedef xmlRef *xmlRefPtr;
  423. struct _xmlRef {
  424.     struct _xmlRef    *next;    /* next Ref */
  425.     const xmlChar     *value;    /* The Ref name */
  426.     xmlAttrPtr        attr;    /* The attribute holding it */
  427.     const xmlChar    *name;    /* The attribute if attr is not available */
  428.     int               lineno;    /* The line number if attr is not available */
  429. };
  430.  
  431. /**
  432.  * xmlNode:
  433.  *
  434.  * A node in an XML tree.
  435.  */
  436. typedef struct _xmlNode xmlNode;
  437. typedef xmlNode *xmlNodePtr;
  438. struct _xmlNode {
  439.     void           *_private;    /* application data */
  440.     xmlElementType   type;    /* type number, must be second ! */
  441.     const xmlChar   *name;      /* the name of the node, or the entity */
  442.     struct _xmlNode *children;    /* parent->childs link */
  443.     struct _xmlNode *last;    /* last child link */
  444.     struct _xmlNode *parent;    /* child->parent link */
  445.     struct _xmlNode *next;    /* next sibling link  */
  446.     struct _xmlNode *prev;    /* previous sibling link  */
  447.     struct _xmlDoc  *doc;    /* the containing document */
  448.  
  449.     /* End of common part */
  450.     xmlNs           *ns;        /* pointer to the associated namespace */
  451.     xmlChar         *content;   /* the content */
  452.     struct _xmlAttr *properties;/* properties list */
  453.     xmlNs           *nsDef;     /* namespace definitions on this node */
  454.     void            *psvi;    /* for type/PSVI informations */
  455.     unsigned short   line;    /* line number */
  456.     unsigned short   extra;    /* extra data for XPath/XSLT */
  457. };
  458.  
  459. /**
  460.  * XML_GET_CONTENT:
  461.  *
  462.  * Macro to extract the content pointer of a node.
  463.  */
  464. #define XML_GET_CONTENT(n)                    \
  465.     ((n)->type == XML_ELEMENT_NODE ? NULL : (n)->content)
  466.  
  467. /**
  468.  * XML_GET_LINE:
  469.  *
  470.  * Macro to extract the line number of an element node. 
  471.  */
  472. #define XML_GET_LINE(n)                        \
  473.     (xmlGetLineNo(n))
  474.  
  475.  
  476. /**
  477.  * xmlDoc:
  478.  *
  479.  * An XML document.
  480.  */
  481. typedef struct _xmlDoc xmlDoc;
  482. typedef xmlDoc *xmlDocPtr;
  483. struct _xmlDoc {
  484.     void           *_private;    /* application data */
  485.     xmlElementType  type;       /* XML_DOCUMENT_NODE, must be second ! */
  486.     char           *name;    /* name/filename/URI of the document */
  487.     struct _xmlNode *children;    /* the document tree */
  488.     struct _xmlNode *last;    /* last child link */
  489.     struct _xmlNode *parent;    /* child->parent link */
  490.     struct _xmlNode *next;    /* next sibling link  */
  491.     struct _xmlNode *prev;    /* previous sibling link  */
  492.     struct _xmlDoc  *doc;    /* autoreference to itself */
  493.  
  494.     /* End of common part */
  495.     int             compression;/* level of zlib compression */
  496.     int             standalone; /* standalone document (no external refs) */
  497.     struct _xmlDtd  *intSubset;    /* the document internal subset */
  498.     struct _xmlDtd  *extSubset;    /* the document external subset */
  499.     struct _xmlNs   *oldNs;    /* Global namespace, the old way */
  500.     const xmlChar  *version;    /* the XML version string */
  501.     const xmlChar  *encoding;   /* external initial encoding, if any */
  502.     void           *ids;        /* Hash table for ID attributes if any */
  503.     void           *refs;       /* Hash table for IDREFs attributes if any */
  504.     const xmlChar  *URL;    /* The URI for that document */
  505.     int             charset;    /* encoding of the in-memory content
  506.                    actually an xmlCharEncoding */
  507.     struct _xmlDict *dict;      /* dict used to allocate names or NULL */
  508.     void           *psvi;    /* for type/PSVI informations */
  509. };
  510.  
  511. typedef struct _xmlDOMWrapCtxt xmlDOMWrapCtxt;
  512. typedef xmlDOMWrapCtxt *xmlDOMWrapCtxtPtr;
  513. struct _xmlDOMWrapCtxt {
  514.     void * _private;
  515. };
  516.  
  517. /**
  518.  * xmlChildrenNode:
  519.  *
  520.  * Macro for compatibility naming layer with libxml1. Maps
  521.  * to "children."
  522.  */
  523. #ifndef xmlChildrenNode
  524. #define xmlChildrenNode children
  525. #endif
  526.  
  527. /**
  528.  * xmlRootNode:
  529.  *
  530.  * Macro for compatibility naming layer with libxml1. Maps 
  531.  * to "children".
  532.  */
  533. #ifndef xmlRootNode
  534. #define xmlRootNode children
  535. #endif
  536.  
  537. /*
  538.  * Variables.
  539.  */
  540.  
  541. /*
  542.  * Some helper functions
  543.  */
  544. #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_DEBUG_ENABLED) || defined (LIBXML_HTML_ENABLED)
  545. XMLPUBFUN int XMLCALL
  546.         xmlValidateNCName    (const xmlChar *value,
  547.                      int space);
  548. #endif
  549.  
  550. #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
  551. XMLPUBFUN int XMLCALL        
  552.         xmlValidateQName    (const xmlChar *value,
  553.                      int space);
  554. XMLPUBFUN int XMLCALL        
  555.         xmlValidateName        (const xmlChar *value,
  556.                      int space);
  557. XMLPUBFUN int XMLCALL        
  558.         xmlValidateNMToken    (const xmlChar *value,
  559.                      int space);
  560. #endif
  561.  
  562. XMLPUBFUN xmlChar * XMLCALL    
  563.         xmlBuildQName        (const xmlChar *ncname,
  564.                      const xmlChar *prefix,
  565.                      xmlChar *memory,
  566.                      int len);
  567. XMLPUBFUN xmlChar * XMLCALL    
  568.         xmlSplitQName2        (const xmlChar *name,
  569.                      xmlChar **prefix);
  570. XMLPUBFUN const xmlChar * XMLCALL    
  571.         xmlSplitQName3        (const xmlChar *name,
  572.                      int *len);
  573.  
  574. /*
  575.  * Handling Buffers.
  576.  */
  577.  
  578. XMLPUBFUN void XMLCALL        
  579.         xmlSetBufferAllocationScheme(xmlBufferAllocationScheme scheme);
  580. XMLPUBFUN xmlBufferAllocationScheme XMLCALL     
  581.         xmlGetBufferAllocationScheme(void);
  582.  
  583. XMLPUBFUN xmlBufferPtr XMLCALL    
  584.         xmlBufferCreate        (void);
  585. XMLPUBFUN xmlBufferPtr XMLCALL    
  586.         xmlBufferCreateSize    (size_t size);
  587. XMLPUBFUN xmlBufferPtr XMLCALL    
  588.         xmlBufferCreateStatic    (void *mem,
  589.                      size_t size);
  590. XMLPUBFUN int XMLCALL        
  591.         xmlBufferResize        (xmlBufferPtr buf,
  592.                      unsigned int size);
  593. XMLPUBFUN void XMLCALL        
  594.         xmlBufferFree        (xmlBufferPtr buf);
  595. XMLPUBFUN int XMLCALL        
  596.         xmlBufferDump        (FILE *file,
  597.                      xmlBufferPtr buf);
  598. XMLPUBFUN int XMLCALL        
  599.         xmlBufferAdd        (xmlBufferPtr buf,
  600.                      const xmlChar *str,
  601.                      int len);
  602. XMLPUBFUN int XMLCALL        
  603.         xmlBufferAddHead    (xmlBufferPtr buf,
  604.                      const xmlChar *str,
  605.                      int len);
  606. XMLPUBFUN int XMLCALL        
  607.         xmlBufferCat        (xmlBufferPtr buf,
  608.                      const xmlChar *str);
  609. XMLPUBFUN int XMLCALL    
  610.         xmlBufferCCat        (xmlBufferPtr buf,
  611.                      const char *str);
  612. XMLPUBFUN int XMLCALL        
  613.         xmlBufferShrink        (xmlBufferPtr buf,
  614.                      unsigned int len);
  615. XMLPUBFUN int XMLCALL        
  616.         xmlBufferGrow        (xmlBufferPtr buf,
  617.                      unsigned int len);
  618. XMLPUBFUN void XMLCALL        
  619.         xmlBufferEmpty        (xmlBufferPtr buf);
  620. XMLPUBFUN const xmlChar* XMLCALL    
  621.         xmlBufferContent    (const xmlBufferPtr buf);
  622. XMLPUBFUN void XMLCALL        
  623.         xmlBufferSetAllocationScheme(xmlBufferPtr buf,
  624.                      xmlBufferAllocationScheme scheme);
  625. XMLPUBFUN int XMLCALL        
  626.         xmlBufferLength        (const xmlBufferPtr buf);
  627.  
  628. /*
  629.  * Creating/freeing new structures.
  630.  */
  631. XMLPUBFUN xmlDtdPtr XMLCALL    
  632.         xmlCreateIntSubset    (xmlDocPtr doc,
  633.                      const xmlChar *name,
  634.                      const xmlChar *ExternalID,
  635.                      const xmlChar *SystemID);
  636. XMLPUBFUN xmlDtdPtr XMLCALL    
  637.         xmlNewDtd        (xmlDocPtr doc,
  638.                      const xmlChar *name,
  639.                      const xmlChar *ExternalID,
  640.                      const xmlChar *SystemID);
  641. XMLPUBFUN xmlDtdPtr XMLCALL    
  642.         xmlGetIntSubset        (xmlDocPtr doc);
  643. XMLPUBFUN void XMLCALL        
  644.         xmlFreeDtd        (xmlDtdPtr cur);
  645. #ifdef LIBXML_LEGACY_ENABLED
  646. XMLPUBFUN xmlNsPtr XMLCALL    
  647.         xmlNewGlobalNs        (xmlDocPtr doc,
  648.                      const xmlChar *href,
  649.                      const xmlChar *prefix);
  650. #endif /* LIBXML_LEGACY_ENABLED */
  651. XMLPUBFUN xmlNsPtr XMLCALL    
  652.         xmlNewNs        (xmlNodePtr node,
  653.                      const xmlChar *href,
  654.                      const xmlChar *prefix);
  655. XMLPUBFUN void XMLCALL        
  656.         xmlFreeNs        (xmlNsPtr cur);
  657. XMLPUBFUN void XMLCALL        
  658.         xmlFreeNsList        (xmlNsPtr cur);
  659. XMLPUBFUN xmlDocPtr XMLCALL     
  660.         xmlNewDoc        (const xmlChar *version);
  661. XMLPUBFUN void XMLCALL        
  662.         xmlFreeDoc        (xmlDocPtr cur);
  663. XMLPUBFUN xmlAttrPtr XMLCALL    
  664.         xmlNewDocProp        (xmlDocPtr doc,
  665.                      const xmlChar *name,
  666.                      const xmlChar *value);
  667. #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED) || \
  668.     defined(LIBXML_SCHEMAS_ENABLED)
  669. XMLPUBFUN xmlAttrPtr XMLCALL    
  670.         xmlNewProp        (xmlNodePtr node,
  671.                      const xmlChar *name,
  672.                      const xmlChar *value);
  673. #endif
  674. XMLPUBFUN xmlAttrPtr XMLCALL    
  675.         xmlNewNsProp        (xmlNodePtr node,
  676.                      xmlNsPtr ns,
  677.                      const xmlChar *name,
  678.                      const xmlChar *value);
  679. XMLPUBFUN xmlAttrPtr XMLCALL    
  680.         xmlNewNsPropEatName    (xmlNodePtr node,
  681.                      xmlNsPtr ns,
  682.                      xmlChar *name,
  683.                      const xmlChar *value);
  684. XMLPUBFUN void XMLCALL        
  685.         xmlFreePropList        (xmlAttrPtr cur);
  686. XMLPUBFUN void XMLCALL        
  687.         xmlFreeProp        (xmlAttrPtr cur);
  688. XMLPUBFUN xmlAttrPtr XMLCALL    
  689.         xmlCopyProp        (xmlNodePtr target,
  690.                      xmlAttrPtr cur);
  691. XMLPUBFUN xmlAttrPtr XMLCALL    
  692.         xmlCopyPropList        (xmlNodePtr target,
  693.                      xmlAttrPtr cur);
  694. #ifdef LIBXML_TREE_ENABLED
  695. XMLPUBFUN xmlDtdPtr XMLCALL    
  696.         xmlCopyDtd        (xmlDtdPtr dtd);
  697. #endif /* LIBXML_TREE_ENABLED */
  698. #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
  699. XMLPUBFUN xmlDocPtr XMLCALL    
  700.         xmlCopyDoc        (xmlDocPtr doc,
  701.                      int recursive);
  702. #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) */
  703. /*
  704.  * Creating new nodes.
  705.  */
  706. XMLPUBFUN xmlNodePtr XMLCALL    
  707.         xmlNewDocNode        (xmlDocPtr doc,
  708.                      xmlNsPtr ns,
  709.                      const xmlChar *name,
  710.                      const xmlChar *content);
  711. XMLPUBFUN xmlNodePtr XMLCALL    
  712.         xmlNewDocNodeEatName    (xmlDocPtr doc,
  713.                      xmlNsPtr ns,
  714.                      xmlChar *name,
  715.                      const xmlChar *content);
  716. XMLPUBFUN xmlNodePtr XMLCALL    
  717.         xmlNewNode        (xmlNsPtr ns,
  718.                      const xmlChar *name);
  719. XMLPUBFUN xmlNodePtr XMLCALL    
  720.         xmlNewNodeEatName    (xmlNsPtr ns,
  721.                      xmlChar *name);
  722. #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
  723. XMLPUBFUN xmlNodePtr XMLCALL    
  724.         xmlNewChild        (xmlNodePtr parent,
  725.                      xmlNsPtr ns,
  726.                      const xmlChar *name,
  727.                      const xmlChar *content);
  728. #endif
  729. XMLPUBFUN xmlNodePtr XMLCALL    
  730.         xmlNewDocText        (xmlDocPtr doc,
  731.                      const xmlChar *content);
  732. XMLPUBFUN xmlNodePtr XMLCALL    
  733.         xmlNewText        (const xmlChar *content);
  734. XMLPUBFUN xmlNodePtr XMLCALL    
  735.         xmlNewDocPI        (xmlDocPtr doc,
  736.                      const xmlChar *name,
  737.                      const xmlChar *content);
  738. XMLPUBFUN xmlNodePtr XMLCALL    
  739.         xmlNewPI        (const xmlChar *name,
  740.                      const xmlChar *content);
  741. XMLPUBFUN xmlNodePtr XMLCALL    
  742.         xmlNewDocTextLen    (xmlDocPtr doc,
  743.                      const xmlChar *content,
  744.                      int len);
  745. XMLPUBFUN xmlNodePtr XMLCALL    
  746.         xmlNewTextLen        (const xmlChar *content,
  747.                      int len);
  748. XMLPUBFUN xmlNodePtr XMLCALL    
  749.         xmlNewDocComment    (xmlDocPtr doc,
  750.                      const xmlChar *content);
  751. XMLPUBFUN xmlNodePtr XMLCALL    
  752.         xmlNewComment        (const xmlChar *content);
  753. XMLPUBFUN xmlNodePtr XMLCALL    
  754.         xmlNewCDataBlock    (xmlDocPtr doc,
  755.                      const xmlChar *content,
  756.                      int len);
  757. XMLPUBFUN xmlNodePtr XMLCALL    
  758.         xmlNewCharRef        (xmlDocPtr doc,
  759.                      const xmlChar *name);
  760. XMLPUBFUN xmlNodePtr XMLCALL    
  761.         xmlNewReference        (xmlDocPtr doc,
  762.                      const xmlChar *name);
  763. XMLPUBFUN xmlNodePtr XMLCALL    
  764.         xmlCopyNode        (const xmlNodePtr node,
  765.                      int recursive);
  766. XMLPUBFUN xmlNodePtr XMLCALL    
  767.         xmlDocCopyNode        (const xmlNodePtr node,
  768.                      xmlDocPtr doc,
  769.                      int recursive);
  770. XMLPUBFUN xmlNodePtr XMLCALL    
  771.         xmlDocCopyNodeList    (xmlDocPtr doc,
  772.                      const xmlNodePtr node);
  773. XMLPUBFUN xmlNodePtr XMLCALL    
  774.         xmlCopyNodeList        (const xmlNodePtr node);
  775. #ifdef LIBXML_TREE_ENABLED
  776. XMLPUBFUN xmlNodePtr XMLCALL    
  777.         xmlNewTextChild        (xmlNodePtr parent,
  778.                      xmlNsPtr ns,
  779.                      const xmlChar *name,
  780.                      const xmlChar *content);
  781. XMLPUBFUN xmlNodePtr XMLCALL    
  782.         xmlNewDocRawNode    (xmlDocPtr doc,
  783.                      xmlNsPtr ns,
  784.                      const xmlChar *name,
  785.                      const xmlChar *content);
  786. XMLPUBFUN xmlNodePtr XMLCALL    
  787.         xmlNewDocFragment    (xmlDocPtr doc);
  788. #endif /* LIBXML_TREE_ENABLED */
  789.  
  790. /*
  791.  * Navigating.
  792.  */
  793. XMLPUBFUN long XMLCALL        
  794.         xmlGetLineNo        (xmlNodePtr node);
  795. #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED)
  796. XMLPUBFUN xmlChar * XMLCALL    
  797.         xmlGetNodePath        (xmlNodePtr node);
  798. #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED) */
  799. XMLPUBFUN xmlNodePtr XMLCALL    
  800.         xmlDocGetRootElement    (xmlDocPtr doc);
  801. XMLPUBFUN xmlNodePtr XMLCALL    
  802.         xmlGetLastChild        (xmlNodePtr parent);
  803. XMLPUBFUN int XMLCALL        
  804.         xmlNodeIsText        (xmlNodePtr node);
  805. XMLPUBFUN int XMLCALL        
  806.         xmlIsBlankNode        (xmlNodePtr node);
  807.  
  808. /*
  809.  * Changing the structure.
  810.  */
  811. #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED)
  812. XMLPUBFUN xmlNodePtr XMLCALL    
  813.         xmlDocSetRootElement    (xmlDocPtr doc,
  814.                      xmlNodePtr root);
  815. #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED) */
  816. #ifdef LIBXML_TREE_ENABLED
  817. XMLPUBFUN void XMLCALL        
  818.         xmlNodeSetName        (xmlNodePtr cur,
  819.                      const xmlChar *name);
  820. #endif /* LIBXML_TREE_ENABLED */
  821. XMLPUBFUN xmlNodePtr XMLCALL    
  822.         xmlAddChild        (xmlNodePtr parent,
  823.                      xmlNodePtr cur);
  824. XMLPUBFUN xmlNodePtr XMLCALL    
  825.         xmlAddChildList        (xmlNodePtr parent,
  826.                      xmlNodePtr cur);
  827. #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED)
  828. XMLPUBFUN xmlNodePtr XMLCALL    
  829.         xmlReplaceNode        (xmlNodePtr old,
  830.                      xmlNodePtr cur);
  831. #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED) */
  832. #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED) || \
  833.     defined(LIBXML_SCHEMAS_ENABLED)
  834. XMLPUBFUN xmlNodePtr XMLCALL    
  835.         xmlAddPrevSibling    (xmlNodePtr cur,
  836.                      xmlNodePtr elem);
  837. #endif /* LIBXML_TREE_ENABLED || LIBXML_HTML_ENABLED || LIBXML_SCHEMAS_ENABLED */
  838. XMLPUBFUN xmlNodePtr XMLCALL    
  839.         xmlAddSibling        (xmlNodePtr cur,
  840.                      xmlNodePtr elem);
  841. XMLPUBFUN xmlNodePtr XMLCALL    
  842.         xmlAddNextSibling    (xmlNodePtr cur,
  843.                      xmlNodePtr elem);
  844. XMLPUBFUN void XMLCALL        
  845.         xmlUnlinkNode        (xmlNodePtr cur);
  846. XMLPUBFUN xmlNodePtr XMLCALL    
  847.         xmlTextMerge        (xmlNodePtr first,
  848.                      xmlNodePtr second);
  849. XMLPUBFUN int XMLCALL        
  850.         xmlTextConcat        (xmlNodePtr node,
  851.                      const xmlChar *content,
  852.                      int len);
  853. XMLPUBFUN void XMLCALL        
  854.         xmlFreeNodeList        (xmlNodePtr cur);
  855. XMLPUBFUN void XMLCALL        
  856.         xmlFreeNode        (xmlNodePtr cur);
  857. XMLPUBFUN void XMLCALL        
  858.         xmlSetTreeDoc        (xmlNodePtr tree,
  859.                      xmlDocPtr doc);
  860. XMLPUBFUN void XMLCALL        
  861.         xmlSetListDoc        (xmlNodePtr list,
  862.                      xmlDocPtr doc);
  863. /*
  864.  * Namespaces.
  865.  */
  866. XMLPUBFUN xmlNsPtr XMLCALL    
  867.         xmlSearchNs        (xmlDocPtr doc,
  868.                      xmlNodePtr node,
  869.                      const xmlChar *nameSpace);
  870. XMLPUBFUN xmlNsPtr XMLCALL    
  871.         xmlSearchNsByHref    (xmlDocPtr doc,
  872.                      xmlNodePtr node,
  873.                      const xmlChar *href);
  874. #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XPATH_ENABLED)
  875. XMLPUBFUN xmlNsPtr * XMLCALL    
  876.         xmlGetNsList        (xmlDocPtr doc,
  877.                      xmlNodePtr node);
  878. #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XPATH_ENABLED) */
  879.  
  880. XMLPUBFUN void XMLCALL        
  881.         xmlSetNs        (xmlNodePtr node,
  882.                      xmlNsPtr ns);
  883. XMLPUBFUN xmlNsPtr XMLCALL    
  884.         xmlCopyNamespace    (xmlNsPtr cur);
  885. XMLPUBFUN xmlNsPtr XMLCALL    
  886.         xmlCopyNamespaceList    (xmlNsPtr cur);
  887.  
  888. /*
  889.  * Changing the content.
  890.  */
  891. #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED)
  892. XMLPUBFUN xmlAttrPtr XMLCALL    
  893.         xmlSetProp        (xmlNodePtr node,
  894.                      const xmlChar *name,
  895.                      const xmlChar *value);
  896. XMLPUBFUN xmlAttrPtr XMLCALL    
  897.         xmlSetNsProp        (xmlNodePtr node,
  898.                      xmlNsPtr ns,
  899.                      const xmlChar *name,
  900.                      const xmlChar *value);
  901. #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED) */
  902. XMLPUBFUN xmlChar * XMLCALL    
  903.         xmlGetNoNsProp        (xmlNodePtr node,
  904.                      const xmlChar *name);
  905. XMLPUBFUN xmlChar * XMLCALL    
  906.         xmlGetProp        (xmlNodePtr node,
  907.                      const xmlChar *name);
  908. XMLPUBFUN xmlAttrPtr XMLCALL    
  909.         xmlHasProp        (xmlNodePtr node,
  910.                      const xmlChar *name);
  911. XMLPUBFUN xmlAttrPtr XMLCALL    
  912.         xmlHasNsProp        (xmlNodePtr node,
  913.                      const xmlChar *name,
  914.                      const xmlChar *nameSpace);
  915. XMLPUBFUN xmlChar * XMLCALL    
  916.         xmlGetNsProp        (xmlNodePtr node,
  917.                      const xmlChar *name,
  918.                      const xmlChar *nameSpace);
  919. XMLPUBFUN xmlNodePtr XMLCALL    
  920.         xmlStringGetNodeList    (xmlDocPtr doc,
  921.                      const xmlChar *value);
  922. XMLPUBFUN xmlNodePtr XMLCALL    
  923.         xmlStringLenGetNodeList    (xmlDocPtr doc,
  924.                      const xmlChar *value,
  925.                      int len);
  926. XMLPUBFUN xmlChar * XMLCALL    
  927.         xmlNodeListGetString    (xmlDocPtr doc,
  928.                      xmlNodePtr list,
  929.                      int inLine);
  930. #ifdef LIBXML_TREE_ENABLED
  931. XMLPUBFUN xmlChar * XMLCALL    
  932.         xmlNodeListGetRawString    (xmlDocPtr doc,
  933.                      xmlNodePtr list,
  934.                      int inLine);
  935. #endif /* LIBXML_TREE_ENABLED */
  936. XMLPUBFUN void XMLCALL        
  937.         xmlNodeSetContent    (xmlNodePtr cur,
  938.                      const xmlChar *content);
  939. #ifdef LIBXML_TREE_ENABLED
  940. XMLPUBFUN void XMLCALL        
  941.         xmlNodeSetContentLen    (xmlNodePtr cur,
  942.                      const xmlChar *content,
  943.                      int len);
  944. #endif /* LIBXML_TREE_ENABLED */
  945. XMLPUBFUN void XMLCALL        
  946.         xmlNodeAddContent    (xmlNodePtr cur,
  947.                      const xmlChar *content);
  948. XMLPUBFUN void XMLCALL        
  949.         xmlNodeAddContentLen    (xmlNodePtr cur,
  950.                      const xmlChar *content,
  951.                      int len);
  952. XMLPUBFUN xmlChar * XMLCALL    
  953.         xmlNodeGetContent    (xmlNodePtr cur);
  954. XMLPUBFUN int XMLCALL
  955.         xmlNodeBufGetContent    (xmlBufferPtr buffer,
  956.                      xmlNodePtr cur);
  957. XMLPUBFUN xmlChar * XMLCALL    
  958.         xmlNodeGetLang        (xmlNodePtr cur);
  959. XMLPUBFUN int XMLCALL        
  960.         xmlNodeGetSpacePreserve    (xmlNodePtr cur);
  961. #ifdef LIBXML_TREE_ENABLED
  962. XMLPUBFUN void XMLCALL        
  963.         xmlNodeSetLang        (xmlNodePtr cur,
  964.                      const xmlChar *lang);
  965. XMLPUBFUN void XMLCALL        
  966.         xmlNodeSetSpacePreserve (xmlNodePtr cur,
  967.                      int val);
  968. #endif /* LIBXML_TREE_ENABLED */
  969. XMLPUBFUN xmlChar * XMLCALL    
  970.         xmlNodeGetBase        (xmlDocPtr doc,
  971.                      xmlNodePtr cur);
  972. #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED)
  973. XMLPUBFUN void XMLCALL        
  974.         xmlNodeSetBase        (xmlNodePtr cur,
  975.                      const xmlChar *uri);
  976. #endif
  977.  
  978. /*
  979.  * Removing content.
  980.  */
  981. #ifdef LIBXML_TREE_ENABLED
  982. XMLPUBFUN int XMLCALL        
  983.         xmlRemoveProp        (xmlAttrPtr cur);
  984. #endif /* LIBXML_TREE_ENABLED */
  985. #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
  986. XMLPUBFUN int XMLCALL        
  987.         xmlUnsetNsProp        (xmlNodePtr node,
  988.                      xmlNsPtr ns,
  989.                      const xmlChar *name);
  990. XMLPUBFUN int XMLCALL        
  991.         xmlUnsetProp        (xmlNodePtr node,
  992.                      const xmlChar *name);
  993. #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) */
  994.  
  995. /*
  996.  * Internal, don't use.
  997.  */
  998. XMLPUBFUN void XMLCALL        
  999.         xmlBufferWriteCHAR    (xmlBufferPtr buf,
  1000.                      const xmlChar *string);
  1001. XMLPUBFUN void XMLCALL        
  1002.         xmlBufferWriteChar    (xmlBufferPtr buf,
  1003.                      const char *string);
  1004. XMLPUBFUN void XMLCALL        
  1005.         xmlBufferWriteQuotedString(xmlBufferPtr buf,
  1006.                      const xmlChar *string);
  1007.  
  1008. #ifdef LIBXML_OUTPUT_ENABLED
  1009. XMLPUBFUN void xmlAttrSerializeTxtContent(xmlBufferPtr buf,
  1010.                      xmlDocPtr doc,
  1011.                      xmlAttrPtr attr,
  1012.                      const xmlChar *string);
  1013. #endif /* LIBXML_OUTPUT_ENABLED */
  1014.  
  1015. #ifdef LIBXML_TREE_ENABLED
  1016. /*
  1017.  * Namespace handling.
  1018.  */
  1019. XMLPUBFUN int XMLCALL        
  1020.         xmlReconciliateNs    (xmlDocPtr doc,
  1021.                      xmlNodePtr tree);
  1022. #endif
  1023.  
  1024. #ifdef LIBXML_OUTPUT_ENABLED
  1025. /*
  1026.  * Saving.
  1027.  */
  1028. XMLPUBFUN void XMLCALL        
  1029.         xmlDocDumpFormatMemory    (xmlDocPtr cur,
  1030.                      xmlChar **mem,
  1031.                      int *size,
  1032.                      int format);
  1033. XMLPUBFUN void XMLCALL        
  1034.         xmlDocDumpMemory    (xmlDocPtr cur,
  1035.                      xmlChar **mem,
  1036.                      int *size);
  1037. XMLPUBFUN void XMLCALL        
  1038.         xmlDocDumpMemoryEnc    (xmlDocPtr out_doc,
  1039.                      xmlChar **doc_txt_ptr,
  1040.                      int * doc_txt_len,
  1041.                      const char *txt_encoding);
  1042. XMLPUBFUN void XMLCALL        
  1043.         xmlDocDumpFormatMemoryEnc(xmlDocPtr out_doc,
  1044.                      xmlChar **doc_txt_ptr,
  1045.                      int * doc_txt_len,
  1046.                      const char *txt_encoding,
  1047.                      int format);
  1048. XMLPUBFUN int XMLCALL        
  1049.         xmlDocFormatDump    (FILE *f,
  1050.                      xmlDocPtr cur,
  1051.                      int format);
  1052. XMLPUBFUN int XMLCALL    
  1053.         xmlDocDump        (FILE *f,
  1054.                      xmlDocPtr cur);
  1055. XMLPUBFUN void XMLCALL        
  1056.         xmlElemDump        (FILE *f,
  1057.                      xmlDocPtr doc,
  1058.                      xmlNodePtr cur);
  1059. XMLPUBFUN int XMLCALL        
  1060.         xmlSaveFile        (const char *filename,
  1061.                      xmlDocPtr cur);
  1062. XMLPUBFUN int XMLCALL        
  1063.         xmlSaveFormatFile    (const char *filename,
  1064.                      xmlDocPtr cur,
  1065.                      int format);
  1066. XMLPUBFUN int XMLCALL        
  1067.         xmlNodeDump        (xmlBufferPtr buf,
  1068.                      xmlDocPtr doc,
  1069.                      xmlNodePtr cur,
  1070.                      int level,
  1071.                      int format);
  1072.  
  1073. XMLPUBFUN int XMLCALL        
  1074.         xmlSaveFileTo        (xmlOutputBufferPtr buf,
  1075.                      xmlDocPtr cur,
  1076.                      const char *encoding);
  1077. XMLPUBFUN int XMLCALL             
  1078.         xmlSaveFormatFileTo     (xmlOutputBufferPtr buf,
  1079.                      xmlDocPtr cur,
  1080.                          const char *encoding,
  1081.                          int format);
  1082. XMLPUBFUN void XMLCALL        
  1083.         xmlNodeDumpOutput    (xmlOutputBufferPtr buf,
  1084.                      xmlDocPtr doc,
  1085.                      xmlNodePtr cur,
  1086.                      int level,
  1087.                      int format,
  1088.                      const char *encoding);
  1089.  
  1090. XMLPUBFUN int XMLCALL        
  1091.         xmlSaveFormatFileEnc    (const char *filename,
  1092.                      xmlDocPtr cur,
  1093.                      const char *encoding,
  1094.                      int format);
  1095.  
  1096. XMLPUBFUN int XMLCALL        
  1097.         xmlSaveFileEnc        (const char *filename,
  1098.                      xmlDocPtr cur,
  1099.                      const char *encoding);
  1100.  
  1101. #endif /* LIBXML_OUTPUT_ENABLED */
  1102. /*
  1103.  * XHTML
  1104.  */
  1105. XMLPUBFUN int XMLCALL        
  1106.         xmlIsXHTML        (const xmlChar *systemID,
  1107.                      const xmlChar *publicID);
  1108.  
  1109. /*
  1110.  * Compression.
  1111.  */
  1112. XMLPUBFUN int XMLCALL        
  1113.         xmlGetDocCompressMode    (xmlDocPtr doc);
  1114. XMLPUBFUN void XMLCALL        
  1115.         xmlSetDocCompressMode    (xmlDocPtr doc,
  1116.                      int mode);
  1117. XMLPUBFUN int XMLCALL        
  1118.         xmlGetCompressMode    (void);
  1119. XMLPUBFUN void XMLCALL        
  1120.         xmlSetCompressMode    (int mode);
  1121.  
  1122. /*
  1123. * DOM-wrapper helper functions.
  1124. */
  1125. XMLPUBFUN xmlDOMWrapCtxtPtr XMLCALL
  1126.         xmlDOMWrapNewCtxt    (void);
  1127. XMLPUBFUN void XMLCALL
  1128.         xmlDOMWrapFreeCtxt    (xmlDOMWrapCtxtPtr ctxt);
  1129. XMLPUBFUN int XMLCALL
  1130.         xmlDOMWrapReconcileNamespaces(xmlDOMWrapCtxtPtr ctxt,
  1131.                      xmlNodePtr elem,
  1132.                      int options);
  1133. XMLPUBFUN int XMLCALL
  1134.         xmlDOMWrapAdoptNode        (xmlDOMWrapCtxtPtr ctxt,
  1135.                      xmlDocPtr sourceDoc,
  1136.                      xmlNodePtr node,
  1137.                      xmlDocPtr destDoc,            
  1138.                      xmlNodePtr destParent,
  1139.                      int options);
  1140. XMLPUBFUN int XMLCALL
  1141.         xmlDOMWrapRemoveNode    (xmlDOMWrapCtxtPtr ctxt,
  1142.                      xmlDocPtr doc,
  1143.                      xmlNodePtr node,
  1144.                      int options);
  1145.  
  1146. #ifdef __cplusplus
  1147. }
  1148. #endif
  1149. #ifndef __XML_PARSER_H__
  1150. #include <libxml/xmlmemory.h>
  1151. #endif
  1152.  
  1153. #endif /* __XML_TREE_H__ */
  1154.  
  1155.